/* 对象的深拷贝和浅拷贝
 *
 * 构造函数：
 *      定义对象时，自动调用；可以重载；构造完成，对象产生；
 * 析构函数：
 *      不带参数，不能重载，只有一个析构函数；析构完成，对象不存在；
 *
 * 对象默认的拷贝构造是做内存的数据拷贝。
 * 浅拷贝未必有错，关键是对象如果占用外部资源，那么浅拷贝就出现问题了。
 * */
#include <iostream>
using namespace std;

class SeqStack{
private:
    int *_pstack;       //动态开辟数组，存储顺序栈的元素
    int _top;           //指向栈顶元素的位置
    int _size;          //数组扩容的总大小

    void resize(){
        int *ptmp=new int [_size*2];
        for (int i = 0; i < _size; ++i) {
            ptmp[i]= _pstack[i];
        }
        delete[] _pstack;
        _pstack=ptmp;
        _size*=2;
    }
public:
    //构造函数可以带参数，所以构造函数可以有多个重载
    SeqStack(int size=10){
        _pstack=new int [size];
        _top=-1;
        _size=size;
        cout<<"SeqStack()"<<endl;
    }

    //自定义拷贝构造
    SeqStack(const SeqStack& src){
        _pstack=new int[src._size];
        for(int i=0;i<=src._top;++i){
            _pstack[i]=src._pstack[i];
        }
        _top=src._top;
        _size=src._size;
    }

    //赋值重载
    void operator=(const SeqStack &src){
        //需要先释放当前对象占用的外部资源
        delete[] _pstack;

        _pstack=new int[src._size];
        for(int i=0;i<=src._top;++i){
            _pstack[i]=src._pstack[i];
        }
        _top=src._top;
        _size=src._size;
    }

    //析构函数不带参数，所以只有一个析构函数
    ~SeqStack(){
        delete[] _pstack;
        _pstack= nullptr;
        cout<<endl<<"~SeqStack()"<<endl;
    };

    void push(int val){
        if (full())
            resize();
        _pstack[++_top]=val;
    }

    void pop(){
        if (empty())
            return;
        --_top;
    }

    int top(){
        return _pstack[_top];
    }

    bool empty(){
        return _top==-1;
    }

    bool full(){
        return _top==_size-1;
    }
};

int main(){
    SeqStack s1(10);
    SeqStack s2=s1;     //默认拷贝构造 同 SeqStack s3(s1);

    s2=s1;              //默认赋值操作  =》 做直接的内存拷贝

    return 0;
}